/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "ui标量部件.h"
#include "core/属性.h"

#include <字符串数值互换.h>




static HANDLE hThread = 0;








C_编辑框Int32::C_编辑框Int32(S_UI创建环境& ctx) : m_开启编辑(false) {
	m_颜色A = S_UI主题::uic_值编辑框背景;
	m_颜色B = S_UI主题::uic_值编辑框边;
}

C_编辑框Int32::~C_编辑框Int32() {
}


C_编辑框F32::C_编辑框F32(S_UI创建环境& ctx) {
	m_颜色A = S_UI主题::uic_值编辑框背景;
	m_颜色B = S_UI主题::uic_值编辑框边;
}

C_编辑框F32::~C_编辑框F32() {
}

C_编辑框UI8::C_编辑框UI8(S_UI创建环境& ctx) {
	m_颜色A = S_UI主题::uic_值编辑框背景;
	m_颜色B = S_UI主题::uic_值编辑框边;
}

C_编辑框UI8::~C_编辑框UI8() {
}

C_编辑框I8::C_编辑框I8(S_UI创建环境& ctx) {
}

C_编辑框I8::~C_编辑框I8() {
}










static void on_布尔编辑框Draw(C_Widget* self, S_2D画布* 画布) {
	C_编辑框Bool* box = dynamic_cast<C_编辑框Bool*>(self);
	box->m_背景绘制.m_属性 = f_vg_gen属性(画布);
	S_凸边图元 图元{};
	图元.属性 = f_vg_get属性(画布, box->m_背景绘制.m_属性);
	box->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
}

static void on_布尔编辑框变换修改(C_Widget* self) {
	C_编辑框Bool* box = dynamic_cast<C_编辑框Bool*>(self);

	box->m_背景绘制.f_alloc(1);

	mat3X2 mat;
	mat.row0 = self->m_Size * 0.1f;
	mat.row1 = self->m_Size * 0.8f;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	box->m_背景绘制.f_set单色填充(0, mat, box->m_颜色A, S_Widget预设图元::m_圆角矩形);
	
}


static bool f_布尔编辑框_鼠标点击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_编辑框Bool* box = dynamic_cast<C_编辑框Bool*>(self);
	(*((bool*)box->m_Value.m_Value)) = !(*((bool*)box->m_Value.m_Value));

	box->f_刷新();

	if (box->m_Value.m_UI->m_Update) {
		box->m_Value.m_UI->m_Update(box->m_Value);
	}
	if(box->mf_值改变回调) box->mf_值改变回调(box, (*((bool*)box->m_Value.m_Value)));
	return true;
}



C_编辑框Bool::C_编辑框Bool(S_UI创建环境& ctx, S_Props& Value) : C_Widget(&ctx) {
	m_颜色A = S_UI主题::uic_值编辑框背景;
	m_颜色B = S_UI主题::uic_值编辑框边;

	mf_DrawFun = on_布尔编辑框Draw;
	mf_变换修改 = on_布尔编辑框变换修改;

	mf_鼠标按键点击 = f_布尔编辑框_鼠标点击;
	mf_值改变回调 = 0;

	m_Value = Value;
	m_Value.m_UI->m_部件 = this;
}

C_编辑框Bool::~C_编辑框Bool() {
}

void C_编辑框Bool::f_刷新() {
	if ((*((bool*)m_Value.m_Value))) {
		m_颜色A = S_UI主题::uic_值编辑框文字焦点背景;
	}
	else {
		m_颜色A = S_UI主题::uic_值编辑框背景;
	}
	m_绘制属性更新 = true;
}


















Inline void f_数值编辑框_补充小数点(std::wstring& text) {
	bool 是否有小数点 = false;
	for (const auto& e : text) {
		if (e == '.') {
			是否有小数点 = true;
			break;
		}
	}

	if (!是否有小数点) {
		text += L".0";
	}
}


static void f_更新属性值(C_数值编辑框* box, S_Props& m_Value) {
	switch (box->m_Value.m_Type) {
	case E_值类型::e_Type_I8:
		break;
	case E_值类型::e_Type_UI8:
		break;
	case E_值类型::e_Type_I16:
		break;
	case E_值类型::e_Type_UI16:
		break;
	case E_值类型::e_Type_I32:
		box->m_Text = f_整数值转宽字符串(f_prop_I32(box->m_Value));

		if (box->m_Value.m_GPU缓存[0].m_Buf) {
			f_buf_I32_at(box->m_Value.m_GPU缓存[0], 0) = f_prop_I32(box->m_Value);
			if(box->m_Value.m_GPU缓存[0].m_Buf->m_Update) box->m_Value.m_GPU缓存[0].m_Buf->m_Update(box->m_Value.m_GPU缓存[0].m_Buf);
		}
		break;

	case E_值类型::e_Type_I64:
		break;

	case E_值类型::e_Type_UI32: {
		box->m_Text = f_整数值转宽字符串(f_prop_UI32(box->m_Value));

		if (box->m_Value.m_GPU缓存[0].m_Buf) {
			f_buf_UI32_at(box->m_Value.m_GPU缓存[0], 0) = f_prop_UI32(box->m_Value);
			if(box->m_Value.m_GPU缓存[0].m_Buf->m_Update) box->m_Value.m_GPU缓存[0].m_Buf->m_Update(box->m_Value.m_GPU缓存[0].m_Buf);
		}
		break;
	}

	case E_值类型::e_Type_F32: {
		box->m_Text = f_浮点数值转宽字符串(f_prop_F32(box->m_Value));
		f_数值编辑框_补充小数点(box->m_Text);

		if (box->m_Value.m_GPU缓存[0].m_Buf) {
			f_buf_F32_at(box->m_Value.m_GPU缓存[0], 0) = f_prop_F32(box->m_Value);
			if (box->m_Value.m_GPU缓存[0].m_Buf->m_Update) box->m_Value.m_GPU缓存[0].m_Buf->m_Update(box->m_Value.m_GPU缓存[0].m_Buf);
		}
		break;
	}

	case E_值类型::e_Type_UI64:
		box->m_Text = f_整数值转宽字符串64(f_prop_UI64(box->m_Value));

		if (box->m_Value.m_GPU缓存[0].m_Buf) {
			f_buf_I32_at(box->m_Value.m_GPU缓存[0], 0) = f_prop_UI64(box->m_Value);
			if(box->m_Value.m_GPU缓存[0].m_Buf->m_Update) box->m_Value.m_GPU缓存[0].m_Buf->m_Update(box->m_Value.m_GPU缓存[0].m_Buf);
		}
		break;
					  

	case E_值类型::e_Type_Vec2:
		box->m_Text = f_浮点数值转宽字符串(((float32*)box->m_Value.m_Value)[box->m_分量]);
		f_数值编辑框_补充小数点(box->m_Text);

		if (box->m_Value.m_GPU缓存[0].m_Buf) {
			((float32*)&f_buf_Vec2_at(box->m_Value.m_GPU缓存[0], 0))[box->m_分量] = ((float32*)box->m_Value.m_Value)[box->m_分量];
			if (box->m_Value.m_GPU缓存[0].m_Buf->m_Update) box->m_Value.m_GPU缓存[0].m_Buf->m_Update(box->m_Value.m_GPU缓存[0].m_Buf);
		}
		break;

	case E_值类型::e_Type_RGB:
	case E_值类型::e_Type_Vec3:
		box->m_Text = f_浮点数值转宽字符串(((float32*)box->m_Value.m_Value)[box->m_分量]);
		f_数值编辑框_补充小数点(box->m_Text);

		if (box->m_Value.m_GPU缓存[0].m_Buf) {
			((float32*)&f_buf_Vec3_at(box->m_Value.m_GPU缓存[0], 0))[box->m_分量] = ((float32*)box->m_Value.m_Value)[box->m_分量];
			if (box->m_Value.m_GPU缓存[0].m_Buf->m_Update) box->m_Value.m_GPU缓存[0].m_Buf->m_Update(box->m_Value.m_GPU缓存[0].m_Buf);
		}
		break;
	case E_值类型::e_Type_Vec4: {
		box->m_Text = f_浮点数值转宽字符串(((float32*)box->m_Value.m_Value)[box->m_分量]);
		f_数值编辑框_补充小数点(box->m_Text);

		if (box->m_Value.m_GPU缓存[0].m_Buf) {
			((float32*)&f_buf_Vec4_at(box->m_Value.m_GPU缓存[0], 0))[box->m_分量] = ((float32*)box->m_Value.m_Value)[box->m_分量];
			if(box->m_Value.m_GPU缓存[0].m_Buf->m_Update) box->m_Value.m_GPU缓存[0].m_Buf->m_Update(box->m_Value.m_GPU缓存[0].m_Buf);
		}
		break;
	}

	case E_值类型::e_Type_uVec2:
	case E_值类型::e_Type_uVec3:
	case E_值类型::e_Type_uVec4: {
		box->m_Text = f_整数值转宽字符串(((uint32*)box->m_Value.m_Value)[box->m_分量]);
		break;
	}

	case E_值类型::e_Type_iVec2:
	case E_值类型::e_Type_iVec3:
	case E_值类型::e_Type_iVec4: {
		box->m_Text = f_整数值转宽字符串(((int32*)box->m_Value.m_Value)[box->m_分量]);
		break;
	}

	}
}


static bool on_数值编辑框鼠标点击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_数值编辑框* box = dynamic_cast<C_数值编辑框*>(self);

	if (C_文本框::g当前操作文本框 && C_文本框::g当前操作文本框 != box) {
		C_文本框::g当前操作文本框->f_输入完成();
	}

	if (box->m_开启编辑 == false) {
		box->m_Text = f_core_get属性到文本(box->m_Value, box->m_分量);
		box->m_颜色A = S_UI主题::uic_数值编辑框开启编辑背景;
	}
	if (!box->m_拖拽) {
		box->f_开启输入();
	}
	box->m_拖拽 = false;
	
	self->m_绘制属性更新 = true;
	return true;
}

static void on_数值编辑框输入完成(C_Widget* self) {
	C_数值编辑框* box = dynamic_cast<C_数值编辑框*>(self);

	f_core_字符串到属性(box->m_Value, box->m_Text, box->m_分量);
	box->m_颜色A = S_UI主题::uic_值编辑框背景;
	box->m_框部件.f_setColor(0, box->m_颜色A);

	box->m_框部件.f_alloc(1);


	box->m_字符绘制.f_alloc(2, 12);
	mat3X2 Mat;
	Mat.row0 = {};
	Mat.row1 = box->m_Size;
	Mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	box->m_字符绘制.f_居中绘制文本({ Mat.row0 , Mat.row1 }, S_UI主题::uic_文字颜色, 0, box->m_Text);
	

	f_更新属性值(box, box->m_Value);
	//if (box->m_Value.m_UI->m_Update) box->m_Value.m_UI->m_Update(box->m_Value);
}

// 参数 wchar_t c  为0 则代表输入完成
static bool f_数值编辑框_输入字符过滤(C_Widget* self, wchar_t c) {
	auto* editBox = dynamic_cast<C_数值编辑框*>(self);
	//std::cout << "input.m_Key.Keys[k] == " << int32(c) << " _ "  << std::endl;
	if ((c >= 2 && c <= 11) || c == S_InputKey::e_KEY_点 || (c >= 42 && c <= 57) || f_getDX按键小键盘值(c) >= 0 ) {
		uint32 num = editBox->m_Text.size();
		switch (editBox->m_Value.m_Type) {
			case E_值类型::e_Type_I8:
			case E_值类型::e_Type_UI8:
				if (num >= 4) {
					if (num > 4) editBox->m_Text.pop_back();
				}
				break;
			
			case E_值类型::e_Type_I16:
			case E_值类型::e_Type_UI16:
				if (num >= 5) {
					if (num > 5) editBox->m_Text.pop_back();
				}
				break;

			case E_值类型::e_Type_I32:
			case E_值类型::e_Type_UI32: 
				if (editBox->m_Text.size() >= 10) {
					if(num > 10) editBox->m_Text.pop_back();
				}
				break;

			case E_值类型::e_Type_I64: 
			case E_值类型::e_Type_UI64: 
				if (editBox->m_Text.size() >= 20) {
					if (num > 20) editBox->m_Text.pop_back();
				}
				break;

			case E_值类型::e_Type_F32:
				if (editBox->m_Text.size() >= 12) {
					if (num > 12) editBox->m_Text.pop_back();
				}
				break;
			default:
				break;
		}

		return true;
	}else if (c == 0) {
		
	}
	
	return false;
}

static E_事件是否传递 on_数值编辑框拖动(C_Widget* 部件, const S_鼠标& 鼠标, S_拖放数据& data) {
	C_数值编辑框* box = ((C_数值编辑框*)部件);
	box->m_拖拽 = true;

	switch (box->m_Value.m_Type) {
	case E_值类型::e_Type_I8:
		break;
	case E_值类型::e_Type_UI8:
		break;
	case E_值类型::e_Type_I16:
		break;
	case E_值类型::e_Type_UI16:
		break;
	case E_值类型::e_Type_I32:
		*((int32*)box->m_Value.m_Value) += 鼠标.abs.x;
		break;
		
	case E_值类型::e_Type_I64:
		break;

	case E_值类型::e_Type_UI32: {
		int64 v = *((uint32*)box->m_Value.m_Value) + 鼠标.abs.x;
		v = DEF_Max(0, DEF_Min(v, 0xffffffff));
		*((uint32*)box->m_Value.m_Value) = v;
		break;
	}

	case E_值类型::e_Type_UI64:
		*((uint64*)box->m_Value.m_Value) = DEF_Max(0, *((uint64*)box->m_Value.m_Value) + 鼠标.abs.x); break;

	case E_值类型::e_Type_F32:
		*((float32*)box->m_Value.m_Value) += 0.01f * 鼠标.abs.x; break;
	

	case E_值类型::e_Type_Vec2:
	case E_值类型::e_Type_Vec3:
	case E_值类型::e_Type_Vec4:
	case E_值类型::e_Type_RGB:
		((float32*)box->m_Value.m_Value)[box->m_分量] += 0.01f * 鼠标.abs.x; break;
	

	case E_值类型::e_Type_uVec2:
	case E_值类型::e_Type_uVec3:
	case E_值类型::e_Type_uVec4: {
		int64 v = ((uint32*)box->m_Value.m_Value)[box->m_分量] + 鼠标.abs.x;
		v = DEF_Max(0, DEF_Min(v, 0xffffffff));
		((uint32*)box->m_Value.m_Value)[box->m_分量] = v;
		//box->m_Text = f_整数值转宽字符串(((uint32*)box->m_Value.m_Value)[box->m_分量]);
		break;
	}
	
	case E_值类型::e_Type_iVec2:
		((int32*)&f_prop_iVec2(box->m_Value))[box->m_分量] += 鼠标.abs.x; break;
	case E_值类型::e_Type_iVec3:
		((int32*)&f_prop_iVec3(box->m_Value))[box->m_分量] += 鼠标.abs.x; break;
	case E_值类型::e_Type_iVec4: 
		((int32*)&f_prop_iVec4(box->m_Value))[box->m_分量] += 鼠标.abs.x; break;
	
	}
	f_更新属性值(box, box->m_Value);

	box->m_绘制属性更新 = true;
	if (box->m_Value.m_UI->m_Update) box->m_Value.m_UI->m_Update(box->m_Value);
	return E_事件是否传递::e_事件传递_终止;
}


static void f_行编辑框Draw(C_Widget* self, S_2D画布* 画布) {
	
	C_数值编辑框* box = dynamic_cast<C_数值编辑框*>(self);
	box->m_框部件.m_属性 = f_vg_gen属性(画布);
	S_凸边图元 图元{};
	图元.属性 = f_vg_get属性指针(画布, box->m_框部件.m_属性);
	box->m_框部件.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
	
	
	auto 字体 = f_surface_get字体(*self->m_UIctx, S_UI主题::ui_默认字体);
	box->m_字符绘制.f_Draw(画布, &字体, box->m_框部件.m_属性);

	图元 = {};
	图元.属性 = f_vg_get属性指针(画布, box->m_框部件.m_属性);
	if (box->m_Value.m_UI->m_部件) {
		C_行编辑框* box_link = dynamic_cast<C_行编辑框*>(box->m_Value.m_UI->m_部件);
	}
	box->m_光标绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色描边);
}

static void f_行编辑框变换修改(C_Widget* self) {
	
	C_数值编辑框* box = dynamic_cast<C_数值编辑框*>(self);

	box->m_字符绘制.f_alloc(2, 20);
	
	mat3X2 Mat;
	Mat.row0 = {};
	Mat.row1 = box->m_Size;
	Mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	

	std::wstring 数值文本;
	if (box->m_Value.m_Type && !box->m_开启编辑) {
		//box->m_Text = f_core_get属性到文本(box->m_Value);
		数值文本 = f_core_get属性到文本(box->m_Value, box->m_分量);
	}
	else {
		数值文本 = box->m_Text;
	}
	

	box->m_字符绘制.f_绘制文本({ Mat.row0 , Mat.row1 }, S_UI主题::uic_文字颜色, 0, box->m_标签, E_对齐方式::e_左对齐, 1.01);
	box->m_字符绘制.f_居中绘制文本({ Mat.row0 , Mat.row1 }, S_UI主题::uic_文字颜色, 1, 数值文本);
	

	uint32 框选数量 = box->m_选取.结束行列.x - box->m_选取.开始行列.x;
	if (box->m_开启编辑 && 框选数量) {
		box->m_框部件.f_alloc(2);

		auto 选取文本 = 数值文本.substr(box->m_选取.开始行列.x + 1, 框选数量);
		auto 偏移文本 = 数值文本.substr(0, box->m_选取.开始行列.x + 1);
		Mat.row0 = f_widget_get文字绘制据中偏移(self, 数值文本, *box->m_字体, S_UI主题::ui_文字间隔);
		Mat.row0.x += f_surface_get字符串宽度(*box->m_字体, 偏移文本, S_UI主题::ui_文字间隔);
		Mat.row1.x = f_surface_get字符串宽度(*box->m_字体, 选取文本, S_UI主题::ui_文字间隔);
		Mat.row1.y = box->m_Size.y;
		Mat.row2 = { DEF_Min(框选数量, S_UI主题::ui_面板圆角半径), 0 };
		box->m_框部件.f_set单色填充(1, Mat, S_UI主题::uic_值编辑框文字焦点背景, S_Widget预设图元::m_圆角矩形);
	}
	else {
		box->m_框部件.f_alloc(1);
	}

	Mat.row0 = {};
	Mat.row1 = box->m_Size;
	Mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	box->m_框部件.f_set单色填充(0, Mat, box->m_颜色A, box->m_图元);


	if (box->m_开启编辑 && !框选数量) {
		box->m_光标绘制.f_alloc(1);

		mat3X2 mat;
		mat.row0 = box->g_光标绘制位置;
		mat.row1.x = 1;
		mat.row1.y = self->m_Size.y;
		mat.row2 = { 0, 0 };
		auto C = f_PackData4X8(S_UI主题::uic_行编辑框光标);
		//auto C2 = f_PackData4X8({0,0,255,255});
		box->m_光标绘制.f_set单色线(0, mat, { 1.0, C, C }, S_Widget预设图元::m_竖线, 2.0);
		//box->m_光标绘制.f_set单色填充(0, mat, S_UI主题::uic_行编辑框光标, S_Widget预设图元::m_竖线, 2.0);
	}
	else {
		box->m_光标绘制.f_Close();
	}
}

static void 数值编辑框_PropUpdate(S_Props& prop) {
	((C_数值编辑框*)prop.m_UI->m_部件)->m_Text = f_core_get属性到文本(prop);
	((C_数值编辑框*)prop.m_UI->m_部件)->m_绘制属性更新 = true;
}


C_数值编辑框::C_数值编辑框(S_UI创建环境& ctx, S_Props& Value, uint8 分量) : C_行编辑框(ctx) {
	m_分量 = 分量;
	m_图元 = S_Widget预设图元::m_圆角矩形;

	m_颜色A = S_UI主题::uic_值编辑框背景;
	m_颜色B = S_UI主题::uic_值编辑框背景;
	//mf_键盘按键敲击 = f_数值编辑框_按键按下;
	m_开启编辑 = false;
	m_对齐方式 = E_对齐方式::e_据中对齐;


	mf_DrawFun		= f_行编辑框Draw;
	mf_变换修改		= f_行编辑框变换修改;
	
	mf_文本过滤		= f_数值编辑框_输入字符过滤;
	//mf_框选时回调	= on_框选时;
	//mf_框选后回调	= on_框选后;
	//mf_文本输入	= on_编辑框文本输入;
	mf_文本输入完成 = on_数值编辑框输入完成;
	mf_鼠标按键点击 = on_数值编辑框鼠标点击;

	m_Value = Value;
	m_Value.m_UI->m_部件 = this;
	m_Value.m_UI->m_Set = 数值编辑框_PropUpdate;

	m_Text = f_core_get属性到文本(m_Value, m_分量);
	m_拖拽 = false;
}

C_数值编辑框::~C_数值编辑框() {
}

void C_数值编辑框::f_输入完成() {
	f_core_字符串到属性(m_Value, m_Text, m_分量);

	C_行编辑框::f_输入完成();

	//if (m_Value.m_UI->m_Update) m_Value.m_UI->m_Update(m_Value);
}

bool C_数值编辑框::f_使用子类拖放事件() {
	if (m_开启编辑) return false;

	mf_拖拽 = on_数值编辑框拖动;
	return true;
}


C_Widget* f_ui_创建数值编辑框(S_UI创建环境& ctx, S_Props& prop, fp_Widget文本回调 f文本输入, fp_Widget文本输入完成 f输入完成) {
	auto* w = new C_数值编辑框(ctx, prop);
	w->mf_文本输入 = f文本输入;
	w->mf_文本输入完成 = f输入完成;
	//w->m_Text = f_整数值转宽字符串w(prop.m_Value)
	return w;
}

C_Widget* f_ui_创建数值编辑框(S_UI创建环境& ctx, S_Props& prop) {
	auto* w = new C_数值编辑框(ctx, prop);
	return w;
}

S_Props* f_ui_get编辑框数值属性(C_Widget* self) {
	auto* view = dynamic_cast<C_数值编辑框*>(self);
	if (view) {
		return &(view->m_Value);
	}
	return 0;
}

void f_ui_设置数值编辑框引用值(C_Widget* w, S_Props prop) {
	auto* view = dynamic_cast<C_数值编辑框*>(w);
	if (view) {
		view->m_Value = prop;
		view->m_Text = f_core_get属性到文本(view->m_Value, view->m_分量);
	}
}

void f_ui_数值部件文本到数值(C_Widget* self) {
	C_数值编辑框* box = dynamic_cast<C_数值编辑框*>(self);
	if (box) {

	}
}

void f_ui_刷新数值编辑框绘制(C_Widget* w) {
	if (C_文本框::g当前操作文本框) return;

	auto* view = dynamic_cast<C_数值编辑框*>(w);
	if (view) {
		view->m_Text = f_core_get属性到文本(view->m_Value, view->m_分量);
	}
}











static void on_RGBA8选择框Draw(C_Widget* self, S_2D画布* 画布) {
	C_RGBA8选择框* box = dynamic_cast<C_RGBA8选择框*>(self);
	box->m_背景绘制.m_属性 = f_vg_gen属性(画布);
	S_凸边图元 图元{};
	图元.属性 = f_vg_get属性(画布, box->m_背景绘制.m_属性);
	box->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
	auto 字体 = f_surface_get字体(*self->m_UIctx, S_UI主题::ui_默认字体);
	box->m_标签绘制.f_Draw(画布, &字体, box->m_背景绘制.m_属性);
}

static void on_RGBA8选择框变换修改(C_Widget* self) {
	C_RGBA8选择框* box = dynamic_cast<C_RGBA8选择框*>(self);

	float32 宽度 = self->m_Size.x * 0.4;

	box->m_背景绘制.f_alloc(1);
	box->m_标签绘制.f_alloc(1, 10);

	mat3X2 mat;
	mat.row0 = {};
	mat.row1 = { self->m_Size.x * 0.4f, self->m_Size.y };
	mat.row2 = { 4, 0 };
	box->m_标签绘制.f_居中绘制文本({ mat.row0, mat.row1 }, S_UI主题::uic_文字颜色, 0, box->m_Value.m_Name);

	mat.row0.x = mat.row1.x;
	mat.row1.x = self->m_Size.x * 0.6f;
	box->m_背景绘制.f_set单色填充(0, mat, f_prop_Rgba8UI(box->m_Value), S_Widget预设图元::m_圆角矩形);
	
}


C_RGBA8选择框::C_RGBA8选择框(S_UI创建环境& ctx, S_Props& prop) : C_Widget(&ctx) {
	m_Value = prop;

	mf_DrawFun = on_RGBA8选择框Draw;
	mf_变换修改 = on_RGBA8选择框变换修改;

	f_setSize({ 60,24 });
}

C_RGBA8选择框::~C_RGBA8选择框()
{
}










static void on_拾色器Draw(C_Widget* self, S_2D画布* 画布) {
	C_RGBA8选择框* box = dynamic_cast<C_RGBA8选择框*>(self);
	box->m_背景绘制.m_属性 = f_vg_gen属性(画布);
	S_凸边图元 图元{};
	图元.属性 = f_vg_get属性(画布, box->m_背景绘制.m_属性);
	box->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);
	auto 字体 = f_surface_get字体(*self->m_UIctx, S_UI主题::ui_默认字体);
	box->m_标签绘制.f_Draw(画布, &字体, box->m_背景绘制.m_属性);
}

static void on_拾色器变换修改(C_Widget* self, mat3X2** t, uint16 num) {
	C_RGBA8选择框* box = dynamic_cast<C_RGBA8选择框*>(self);

	float32 宽度 = self->m_Size.x * 0.4;

	box->m_背景绘制.f_alloc(1);
	box->m_标签绘制.f_alloc(1, 10);

	mat3X2 mat;
	mat.row0 = {};
	mat.row1 = { self->m_Size.x * 0.4f, self->m_Size.y };
	mat.row2 = { 4, 0 };
	box->m_标签绘制.f_居中绘制文本({ mat.row0, mat.row1 }, S_UI主题::uic_文字颜色, 0, box->m_Value.m_Name);

	mat.row0.x = mat.row1.x;
	mat.row1.x = self->m_Size.x * 0.6f;
	box->m_背景绘制.f_set单色填充(0, mat, f_prop_Rgba8UI(box->m_Value), S_Widget预设图元::m_圆角矩形);

}

static bool g上层鼠标以移出 = false;

static DWORD WINAPI f_弹窗面板关闭(LPVOID pParam) {
	int i = 0;
	Sleep(600);
	if (g上层鼠标以移出) {
		f_widget_顶层窗口_pop(0);
	}
	return 0;
}

static bool on_拾色器鼠标进入(C_Widget* self, const S_鼠标& 轮值) {
	g上层鼠标以移出 = false;

	uint8 topNum = f_widget_getTopNum();
	//f_widget_顶层窗口_pop(menu->m_layer + 1);
	return false;
}

static bool on_拾色器鼠标移出(C_Widget* self, const S_鼠标& 轮值) {
	uint8 topNum = f_widget_getTopNum();
	//创建线程
	hThread = CreateThread(NULL, 0, f_弹窗面板关闭, NULL, 0, NULL);
	return false;
}
C_拾色器::C_拾色器(S_UI创建环境& ctx, S_Props& prop)
{
	mf_鼠标进入 = on_拾色器鼠标进入;
	mf_鼠标离开 = on_拾色器鼠标移出;


	f_widget_顶层窗口_pop(0);
	f_widget_弹出顶层窗口(this);
}
